home *** CD-ROM | disk | FTP | other *** search
/ PD ROM 1 / PD ROM Volume I - Macintosh Software from BMUG (1988).iso / Programming / Programming Tools / SimpleTools2 < prev   
Encoding:
Text File  |  1986-12-15  |  49.3 KB  |  1,771 lines  |  [TEXT/ttxt]
  1. /* Written 11:33 pm  Nov 25, 1986 by erik@hpsadla.HP in uiucdcsb:comp.sys.mac */
  2. /* ---------- "SimpleTools2 - "C" aid (complete so" ---------- */
  3.  
  4.  
  5.  
  6. /*
  7.     Title    : SimpleTools2.c
  8.     Author    : Erik Kilk  Copyright 1985, 1986
  9.     Date    : June 7, 1985, June 3, 1986, November 8, 1986
  10.     
  11.     SimpleTools is a collection of routines to aid programming
  12.     simple "Macintosh looking" programs.  SimpleTools initializes
  13.     the toolbox, monitors & acts upon events, and provides generic
  14.     i/o routines for your application.  You initialize your program
  15.     by letting SimpleTools know what windows and menus you want along
  16.     with what functions SimpleTools should call when they are
  17.     selected.
  18.     
  19.     The purpose of SimpleTools is to encourage you to program those
  20.     simple programs or to pilot larger programs which you may not
  21.     do due to the enormous effort required to use the Macintosh
  22.     toolbox.  My goal was to study Inside Macintosh once to
  23.     Create SimpleTools and then be able to forget most of the usages
  24.     of the Toolbox routines.  Instead of thumbing through hundreds of
  25.     pages of Inside Macintosh just to get something up and running,
  26.     one need only remember a dozen generic calls.
  27.  
  28.     SimpleTools is very powerful, yet also very simple to use.  One
  29.     can get a program up and running with desk accessories, windows,
  30.     and menus in only a few minutes.  Advance features of SimpleTools
  31.     allow you to retrieve enough information from SimpleTools to call
  32.     any of the toolbox routines manually if need be.  
  33.     
  34.     
  35. =========================================================================
  36.  
  37.     You may use, study, copy, and freely distribute SimpleTools if:
  38.         1)  You mention "Programmed with the aid of SimpleTools
  39.             (c) Erik Kilk 1986" in your About... window of all
  40.             programs distributed free, share, or marketted.
  41.         2)  You register by sending $20 or more to:
  42.             Erik Kilk
  43.             4949 Snyder Lane, #247
  44.             Rohnert Park, CA  94928
  45.             (707) 794-2424 weekday afternoons
  46.             to encourage me to maintain and improve SimpleTools.
  47.             
  48. ==>    For a diskette including the most recent version of SimpleTools, 
  49.     several detailed examples of using SimpleTools, and a MacWrite file
  50.     describing SimpleTools and its use in more detail, send me a
  51.     diskette with enough stamps to mail it back to you.  Make sure you
  52.     have registered as stated above.
  53.         
  54.     This is 128k, MFS, HFS, old ROM, new ROM, Mac+, & TMON compatible.
  55.     This file compiles and executes with Megamax 3.0 beta and
  56.     LightSpeed 2.1.  Adjust the definition in simple.h for your
  57.     compiler.  When porting to other compilers, pay particular
  58.     attention to where the Lightspeed and Megamax code is specified
  59.     since these places are the likely problem areas.
  60.     
  61.     LIGHTSPEED NOTE:
  62.     
  63.     Drag SimpleTools out of the main segment in your project window.
  64.     You do this by dragging it below the dotted horizontal Line in the
  65.     project window.
  66.     
  67.     MEGAMAX NOTE:
  68.     
  69.     Use Megamax's convert utility to convert all Mac names to all
  70.     lower case.  If you send me suggestions and/or new code for
  71.     SimpleTools, please convert back to mixed case first.
  72.     
  73. =========================================================================
  74.     
  75.     SimpleTools provides the following functions for your application
  76.     to call.  Note that your application need not call any Toolbox
  77.     routines directly.  The entire C program (including the standard
  78.     desk accessory support):
  79.     
  80.             main ()
  81.             {
  82.                 simpletools ("Skel");
  83.                 simplequits ();
  84.                 runsimpletools ();
  85.             }
  86.             
  87.     will execute as a Macintosh program, terminating upon the user
  88.     selecting Quit.  SimpleTools includes:
  89.     
  90.         simpletools ()        - init Toolbox and SimpleTools
  91.         simplequits ()        - add Transfer & Quit menus
  92.         simpleevents ()        - process next Mac event
  93.         runsimpletools ()    - continuously process events
  94.         
  95.         menu ("File","New",new) - install a menu
  96.         window ("My Window",..)    - install a window
  97.                     
  98.         run (function)        - install a periodic function
  99.         stop (function)        - remove a periodic function
  100.         
  101.         havenewrom ()        - test for new 128k ROM
  102.         withwindow("My Window")    - set output to a window
  103.         
  104.         stgotoxy (x, y)        - set pen to text position x, y
  105.         home ()            - clear window, set pen to home
  106.         getline (deflt, dest)    - with TE editing, get a Line
  107.         prompt (question, dest)    - with dialog box & TE, get a Line
  108.         message (string)    - with dialog box, print a string
  109.         getfile ("TEXT", name)    - with list, select a filename
  110.         putfile (orig, name)    - with list, select a filename
  111.         
  112.     
  113.     A complete Macintosh Style application (including windowing and 
  114.     menus) is given in the following trivial example...
  115.     
  116.         #include <simple.h>
  117.         
  118.         char name[50];
  119.         
  120.         got_beep()        
  121.         {
  122.             SysBeep (10);
  123.         }
  124.         
  125.         got_getname()
  126.         {
  127.             char newname[50];
  128.             *newname = 0;
  129.             if (prompt ("What is your name?", newname)) {
  130.                 strcpy (name, newname);
  131.                 withwindow ("My Window");
  132.                 home();
  133.                 update();
  134.             }
  135.         }
  136.         
  137.         in_content(x, y)
  138.         int x, y;
  139.         {
  140.             MoveTo (x, y); LineTo (x, y);
  141.         }
  142.         
  143.         update()
  144.         {
  145.             char outstring[100];
  146.             stgotoxy (1, 5);
  147.             sprintf (outstring,"Hello, %s", name);
  148.             #ifndef MEGAMAX
  149.               CtoPstr (outstring);
  150.             #endif
  151.             DrawString (outstring);
  152.         }
  153.         
  154.         main ()
  155.         {
  156.             simpletools ("Sample Program");
  157.             simplequits ();
  158.             menu ("Commands", "Beep", got_beep);
  159.             menu ("Commands", "Get Name", got_getname);
  160.             strcpy (name, "World");
  161.             window ("My Window",0,0,0,0,0L,0L,update,
  162.                 in_content);
  163.             runsimpletools ();
  164.         }
  165.         
  166. =========================================================================
  167.  
  168.     ROUTINES YOUR APPLICATION MAY CALL:
  169.     
  170.     
  171.     simpleevents ()
  172.     
  173.     To be called repeatedly by your program's main routine.  In
  174.     most SimpleTools programs, your main routine will initialize
  175.     and install SimpleTools followed by an loop such as:
  176.     
  177.         for (;;) simpleevents();
  178.         
  179.     This routine handles all window changes, menu requests, and
  180.     other Macintosh events.  There is also a routine called with
  181.     runsimpletools() which does not return.  It simply performs the
  182.     above loop.  Program exit is accomplished by assigning an
  183.     exiting routine to a menu, usually this is File/Quit.
  184.         
  185.     
  186.     simpletools (about_string)
  187.     char *about_string;
  188.     
  189.     To be called once at the very beginning of your main routine.
  190.     This routine initializes all the Macintosh software managers
  191.     and installs the basic Apple, File, and Edit menus.  The 
  192.     about_string is the name of the menu Item to appear first under
  193.     the Apple menu.
  194.     
  195.     
  196.     simplequits ()
  197.     
  198.     Installs a simple File/Quit and File/Transfer menu.  You only
  199.     want to installs these if no application dependent processing
  200.     must be done when the user selects Quit or Transfer.
  201.     
  202.     
  203.     menu (name, Item, routine)
  204.     char     *name;
  205.     char     *Item;
  206.     ProcPtr    routine;
  207.     
  208.     To be called when a new menu is to be installed on the menu bar
  209.     or when the characteristics of that menu are to be modified.
  210.     Name is the name of the menu to appear on the menu bar.  Item
  211.     is the name of the Item to appear under the menu name.  Routine
  212.     is the name of the routine to be executed when the stated menu/Item
  213.     has been selected.  The characteristics of the menu may be changed
  214.     by passing one of the constants ItemDisable, itemenable, itemcheck,
  215.     or itemuncheck in place of the routine.
  216.     
  217.     
  218.     window (name, xtop, ytop, xbot, ybot, act, deact, update, content)
  219.     char     *name;
  220.     int      xtop, ytop;
  221.     int      xbot, ybot;
  222.     ProcPtr    act, deact, update, content;
  223.     
  224.     To be called when a new window is to be installed on the screen
  225.     or when the characteristics of that window are to be modified.
  226.     Name is the name of the window.  Xtop, ytop, xbot, and ybot are
  227.     the initial coordinates of the new window.  Act is the name of
  228.     the procedure to execute when the window becomes the top or
  229.     active window.  Deact is the name of the procedure to execute when
  230.     the window ceases being the top window and deactivates.  Update
  231.     is the name of the procedure called when the Macintosh needs to
  232.     redraw the window's contents.  Content is the name of the procedure
  233.     called when the mouse is pressed within the window.  The procedure
  234.     specified as content will be passed an x and y integer value
  235.     representing the local mouse coordinates.
  236.     
  237.     
  238.     withwindow (name)
  239.     char *name;
  240.     
  241.     To be called when you want to select which window will receive
  242.     output and drawings.  In most cases, SimpleTools will select the
  243.     appropriate window before calling your specified act, deact,
  244.     update, or content procedures.  Use this at other times.
  245.     
  246.     
  247.     run (routine)
  248.     ProcPtr    routine;
  249.     
  250.     To be called when you want a routine to be continuously executed
  251.     once each time simpleevents() is called.  Small, quickly running
  252.     routines should be used so as not to Delay the next event
  253.     processing.  Pseudo multiprocessing with each routine running in
  254.     its own window can be accomplished by making sure a run routine
  255.     uses withwindow() to direct its output to the proper window.
  256.     
  257.     
  258.     stop (routine)
  259.     ProcPtr routine;
  260.     
  261.     To be called when you want to remove a previously run() routine
  262.     from the list of routines to run.  50 routines can fit into the
  263.     run list.
  264.     
  265.     
  266.     home ()
  267.     
  268.     Clears the current window and positions the pen such that any
  269.     following text will appear in the upper left corner of the
  270.     window.
  271.     
  272.     
  273.     stgotoxy (column, row)
  274.     int column, row;
  275.     
  276.     Positions the pen in the current window so that the next text
  277.     output will appear in text row and column.  This is compatible
  278.     with some old text only terminals.  stgotoxy (1, 1) positions the
  279.     pen in the upper left corner.  Any negative coordinate leaves
  280.     that axis of the pen where it currently is.
  281.     
  282.     
  283.     getline (default, destination)
  284.     char *default;
  285.     char *destination;
  286.     
  287.     Calling this routine begins a "modal" mode where the user is
  288.     required to enter a Line of text.  This would be similar to
  289.     using scanf() on "non-Mac", text-only terminals.  This routine
  290.     uses the Macintoshes built in Text-Edit routines allowing the
  291.     user to edit his Line until <RETURN> is pressed.  The flashing
  292.     bar Cursor is positioned at the current pen location.  The 
  293.     resulting string is placed into destination.  Default contains
  294.     the initial value to be displayed on the screen.  You may use
  295.     the null string "" for default.
  296.     
  297.     
  298.     prompt (question, answer)
  299.     char *question;
  300.     char *answer;
  301.     
  302.     This routine places a small 3-lined Macintosh Style dialog window
  303.     prompting the user with question and getting the answer in a
  304.     boxed Text-Edit area.  Two buttons are displayed to terminate the
  305.     user entry.  If Cancel is clicked upon, FALSE is returned.  If
  306.     okay is clicked upon, TRUE is returned.  Answer must be set to
  307.     a default value, "" is okay.
  308.     
  309.     
  310.     message (message)
  311.     char *message;
  312.     
  313.     This routine is similar to prompt except no textual response is
  314.     asked from the user.  This is like an Alert dialog.  Just like
  315.     prompt, TRUE or FALSE is returned depending upon which Button the
  316.     user presses.
  317.     
  318.     
  319.     getfile (file_type, reply)
  320.     char *file_type;
  321.     char *replay;
  322.     
  323.     This routine places the standard Macintosh SFGetFile() window
  324.     up with a list of files of file_type.  Once the user selects a
  325.     file, the answer is returned in the string reply.  Also, and
  326.     very important for HFS, the working volume/folder is set so that
  327.     any subsequent open() with reply as the file name will open the
  328.     correct selected file.  The open() should be done before someone
  329.     has a chance to change the working volume.  This routine will 
  330.     return FALSE if the user selects the CANCEL Button.
  331.     
  332.     
  333.     putfile (origname, reply)
  334.     char *origname;
  335.     char *reply;
  336.     
  337.     This routine is like getfile, except the standard putfile window
  338.     is displayed with origname as the default name to save a file as.
  339.     The actual name selected by the user is returned in reply.  As
  340.     getfile, the working volume/folder is set properly for the next
  341.     open() call.
  342.  
  343. =========================================================================
  344.  
  345.     THE FOLLOWING IS THE FILE simple.h.  YOU SHOULD COPY THIS PORTION
  346.     INTO A NEW FILE NAMED simple.h SO YOU CAN #include IT INTO YOUR
  347.     SOURCE FILES.
  348.     
  349. =========================================================================
  350.  
  351. #define LIGHTSPEED    {define either LIGHTSPEED or MEGAMAX or your own}
  352.  
  353. #include <stdio.h>
  354.  
  355. #ifdef MEGAMAX
  356.   #include <menu.h>
  357.   #include <win.h>
  358. #endif
  359.  
  360. #ifdef LIGHTSPEED
  361.   #include <MenuMgr.h>
  362.   #include <WindowMgr.h>
  363. #endif
  364.  
  365. #define ItemDisable    0L        
  366. #define itemenable    1L
  367. #define itemcheck    2L
  368. #define itemuncheck    3L
  369.  
  370. extern char         applestring[];
  371. extern WindowPtr     windowpoint();
  372. extern MenuHandle     mhand();
  373. extern int         windmenu;
  374. extern int         dogoaway;        
  375. extern int         wprocid;        
  376. extern int         sizeredraw;
  377. extern int        getlinecaps;
  378. extern ProcPtr         keydownproc;
  379. extern ProcPtr         autokeyproc;
  380. extern int        home();
  381.  
  382. =========================================================================
  383.  
  384.         Here begins SimpleTools.c
  385.         _________________________
  386. */
  387.  
  388. #include <simple.h>            /* define compiler in here    */
  389.  
  390. #ifdef MEGAMAX                            
  391.         overlay "simpletools"        /* compiler dependent        */
  392.  
  393.     #include <mem.h>
  394.     #include <qd.h>
  395.     #include <qdvars.h>
  396.     #include <misc.h>
  397.     #include <event.h>
  398.     #include <res.h>
  399.     #include <win.h>
  400.     #include <dialog.h>
  401.     #include <menu.h>
  402.     #include <string.h>
  403.     #include <stdio.h>
  404.     #include <pack.h>
  405.     #include <te.h>
  406.     #include <toolbox.h>
  407.     
  408.     #define  ZZ    &
  409. #else
  410.     #include <MemoryMgr.h>
  411.     #include <Quickdraw.h>
  412.     #include <EventMgr.h>
  413.     #include <ResourceMgr.h>
  414.     #include <WindowMgr.h>
  415.     #include <TextEdit.h>
  416.     #include <DialogMgr.h>
  417.     #include <MenuMgr.h>
  418.     #include <strings.h>
  419.     #include <stdio.h>
  420.     #include <PackageMgr.h>
  421.     #include <ToolboxUtil.h>
  422.     #include <StdFilePkg.h>
  423.     #include <pascal.h>
  424.     
  425.     #define  ZZ    
  426. #endif
  427.  
  428. #define TRUE (-1)        /* local definitions             */
  429. #define FALSE 0
  430. #define maxsruns 50        /* procedure table size            */
  431. #define MESSN 30        /* array size for message dialog items    */
  432. #define QUESN 40        /* array size for prompt dialog items    */
  433. #define ROM85   0x28E        /* new rom stuff             */
  434. #define NEWROM  0x7FFF
  435. #define inzoomout 8
  436. #define inzoomin  7
  437. #define zoomproc  8
  438.  
  439. typedef struct {            /* structure for an Item    */
  440.     char        itemname[40];
  441.     int        itemno;        /* Item number within menu     */
  442.     int        menuId;        /* menu id            */
  443.     MenuHandle    menuhand;    /* Item's menu's Handle                 */
  444.     ProcPtr        menurun;    /* procedure to run         */
  445.     Ptr        next;        /* pointer to the next Item     */
  446. } itemdatum;
  447.  
  448. typedef struct {            /* structure for a menu     */
  449.     char         menuname[20];    /* to allow reference by name     */
  450.     int         menuId;        /* menu id             */
  451.     MenuHandle    menuhand;    /* menu Handle to reference menu*/
  452.     itemdatum    **itemlist;    /* pointer to the list of items */
  453.     Ptr         next;        /* pointer to the next menu     */
  454. } menudatum;
  455.  
  456. typedef struct {            /* structure for a window     */
  457.     char        windname[80];    /* window's name and reference     */
  458.     WindowPtr    wptr;        /* window's pointer reference     */
  459.     ProcPtr    wact;            /* the activate procedure     */
  460.     ProcPtr    wdeact;            /* the deactivate procedure     */
  461.     ProcPtr    wupdate;        /* the update procedure     */
  462.     ProcPtr    wcontent;        /* the content procedure     */
  463.     Ptr        next;        /* pointer to the next window     */
  464. } winddatum;
  465.  
  466. #ifdef LIGHTSPEED
  467.   pascal Boolean     *TrackBox() = 0xA83B; 
  468.   pascal void         *ZoomWindow() = 0xA83A;
  469. #endif
  470.  
  471. WindowPtr windowpoint();
  472.  
  473. /* Local variables */
  474.  
  475. menudatum     **simplemenus;        /* Handle to menu data         */
  476. char         accname[80];        /* desk accessory name to open     */
  477. Rect         dragrect, sizerect;    /* limits for moving windows     */
  478. Rect         swholescreen;
  479. winddatum    **simplewinds;        /* Handle to window data     */
  480. int        firstwind;        /* if no windows have been made    */
  481. ProcPtr     simpleruns[maxsruns];    /* list of procedures to run     */
  482. WindowPtr    debugw;            /* window pointer for debugging */
  483. int        snewrom;
  484. int        getlinecaps = FALSE;
  485.  
  486. /************************************************************************/
  487. /* GLOBAL USER MODIFIABLE VARIABLES                     */
  488. /* These are variables that you can declare extern so that you can use    */
  489. /* them to change the SimpleTools defaults                */
  490. /************************************************************************/
  491.  
  492. /* wprocid = type of window to Create on next window() call        */
  493. /* For LightSpeed C, use a lower case d and upper case P for         */
  494. /*     DocumentProc.  Megamax conversion program does this wrong.    */
  495.  
  496. int         wprocid = documentProc;    
  497.  
  498. /* dogoaway = is the next created window to have a go-away box        */
  499.  
  500. int         dogoaway = TRUE;    
  501.  
  502. /* keydownproc = the procedure to be called when keyDown is detected    */
  503. /* autokeyproc = the procedure to be called when autoKey is detected    */
  504. /* BOTH OF THESE ARE PASSED THE EVENTRECORD SO THE KEY CAN BE FOUND    */
  505.  
  506. ProcPtr     keydownproc,
  507.           autokeyproc;         
  508.         
  509. /* applestring = a string containing the Apple for menu reference    */
  510.  
  511. char         applestring[2] 
  512.           = {'\024', '\0'};     
  513.  
  514. /* windmenu = does the next window created get a choice under the
  515.               window menu (so a closed window can be brought back    */
  516.               
  517. int         windmenu = TRUE;    
  518.  
  519. /* sizeredraw = is the window's content area erased and made
  520.                 updateable upon being resized                */
  521.                 
  522. int        sizeredraw = FALSE;    
  523.  
  524.  
  525. /******************************************************************/
  526. /* Dialog lists.  These were calculated by using the new resource */
  527. /* editor to make a template for a dialog and then using fedit to */
  528. /* list the hex listing of the Item list for the dialog.      */
  529. /******************************************************************/
  530.  
  531. int messd[MESSN] = {2,0,0,0x38,0xf1,0x4c,0x12d,0x402,0x4f4b,0,0,5,5,
  532.         0x36,0x12d,0x800,0,0,0x38,0xac,0x4c,0xe8,0x406,
  533.         0x4361,0x6e63,0x656c};
  534. int quesd[QUESN] = {3,0,0,0x21,0xf0,0x35,0x12c,0x402,0x4f4b,0,0,8,8,
  535.         0x28,0xe8,0x800,0,0,0x2b,8,0x4b,0xe8,0x1000,0,0,
  536.         8,0xf0,0x1c,0x12c,0x406,0x4361,0x6e63,0x656c};
  537.         
  538.         
  539. /* Local procedure */
  540.  
  541. stnop()                /* a no op procedure for defaults     */
  542. {
  543. }
  544.  
  545. char *ptoc(s)
  546. char *s;
  547. {
  548.     #ifndef MEGAMAX
  549.         return (PtoCstr(s));
  550.     #else
  551.         return (s);
  552.     #endif
  553. }
  554.  
  555. char *ctop(s)
  556. char *s;
  557. {
  558.     #ifndef MEGAMAX
  559.         return (CtoPstr(s));
  560.     #else
  561.         return (s);
  562.     #endif
  563. }
  564.  
  565. /* Given a menu name, find our data structure for it.  Return a Handle
  566.    to this structure.  This is a local procedure for SimpleTools use.
  567. */
  568.  
  569. /* local procedure */
  570.  
  571. menudatum **getourmenuhandle (name)
  572. char *name;                /* name of menu bar menu */
  573. {
  574.     menudatum **here, **temp;    /* hand to menu structure*/
  575.     here = simplemenus;
  576.  
  577.     /* find the menu name or the end of out menu list */
  578.     HLock (here);
  579.     while (strcmp(name,(**here).menuname) && (**here).next )  {
  580.         temp = here;
  581.         here = (menudatum **)(**here).next;
  582.         HUnlock (temp);
  583.         HLock (here);
  584.     }
  585.         
  586.     /* see if we found it or just the end of the list */
  587.     if (!strcmp(name,(**here).menuname)) {
  588.         HUnlock (here);
  589.         return (here);
  590.     } else {
  591.         HUnlock (here);
  592.         return ((menudatum **)0L);        
  593.     }
  594. }
  595.  
  596. /* This takes a Handle to our personal Item record and either a 
  597.    procedure name or a modifier code.  If it got a procedure name,
  598.    it sets it to the Item's procedure to run when the Item is chosen.
  599.    If it got a modifier code, it changes the state of the menu's Item
  600.    to checked, unchecked, enabled, or disabled.  It especially keeps 
  601.    track of the standard Edit menu items so we can restore them after
  602.    a desk accessory is finished.
  603. */
  604.  
  605. /* Local procedure */
  606.  
  607. setitems ( items, routine)    /* set a menu Item's routine or display */
  608. itemdatum    **items;    /* if items is neg, then whole menu     */
  609. ProcPtr    routine;
  610. {
  611.     int            inumber;
  612.     MenuHandle        mhand;
  613.     
  614.     /* check to see if a procedure pointer was given to us */
  615.     if ( (((long)items)>0L) && (routine > (ProcPtr)0x1000L)) {  
  616.                         /* good procedure value */
  617.         (**items).menurun = routine;
  618.         return;
  619.     }
  620.     
  621.     /* Calculate which Item number we are going to modify */
  622.     if ( (long)items < 0L) {        /* the whole menu     */
  623.         mhand = (MenuHandle) (0L - (long)items);
  624.         inumber = 0;
  625.     } else {                /* just one Item     */
  626.         mhand = (**items).menuhand;
  627.         inumber = (**items).itemno;
  628.     }
  629.  
  630.     /* If a NULL procedure pointer, then set to a no_op routine */
  631.     if ( (inumber > 0) && ((**items).menurun == (ProcPtr)0L) )
  632.         (**items).menurun = stnop;
  633.  
  634.     /* Now change the state of a menu Item */
  635.     switch ((int)routine) {
  636.         case ItemDisable: 
  637.             DisableItem(mhand,inumber); break;
  638.         case itemenable:
  639.             EnableItem(mhand, inumber); break;
  640.         case itemcheck:
  641.             CheckItem(mhand, inumber, TRUE); break;
  642.         case itemuncheck:
  643.             CheckItem(mhand, inumber, FALSE); break;
  644.     }
  645.     if (inumber == 0) DrawMenuBar();  /* if main menu was changed     */
  646.     
  647. }
  648.  
  649. /* This routine is called by the simpletools() initial routine.  It gets
  650.    the pointer list of menus started, loads the desk accessories into
  651.    the Apple menu, and loads up some standard menu entries.  The reason
  652.    menu File has a New entry, and none others, is because as this code
  653.    currently stands, a menu must have at least one Item.  And since we
  654.    want File before Edit, I had to make an entry.  The most commonly used
  655.    Item under File is Quit.  But we like quit to be at the end of the list.
  656.    So, since New is usually always first when it is used, that the one
  657.    chosen to start File.  
  658. */
  659.  
  660. /* Local procedure */
  661.  
  662. initsmenus(about)            /* init simpletools' menus */
  663. char *about;
  664. {
  665.     itemdatum **items;
  666.  
  667.     simplemenus = (menudatum **) NewHandle ( (long)sizeof(menudatum));
  668.     HLock (simplemenus);
  669.  
  670.     strcpy ( (**simplemenus).menuname, applestring);
  671.     (**simplemenus).menuId = 1;
  672.     (**simplemenus).next = (Ptr) 0L;
  673.     ctop ((**simplemenus).menuname);
  674.     (**simplemenus).menuhand = NewMenu (1, (**simplemenus).menuname);
  675.     ptoc ((**simplemenus).menuname);
  676.     HUnlock ((**simplemenus).menuhand);
  677.  
  678.     (**simplemenus).itemlist = (itemdatum **)NewHandle ( 
  679.             (long)sizeof(itemdatum));
  680.     items = (itemdatum **) (**simplemenus).itemlist;
  681.     HLock (items);
  682.  
  683.     strcpy ((**items).itemname, about);
  684.     (**items).itemno = 1;
  685.     (**items).menuId = 1;
  686.     (**items).menuhand = (**simplemenus).menuhand;
  687.     (**items).menurun = stnop;
  688.     (**items).next = 0L;
  689.     HUnlock (items);
  690.  
  691.     ctop (about);
  692.     AppendMenu ((**simplemenus).menuhand, about);
  693.     ptoc (about);
  694.     DisableItem ((**simplemenus).menuhand, 1);
  695.     menu (applestring, "-", (ProcPtr) ItemDisable);
  696.     #ifdef MEGAMAX
  697.       AddResMenu ((**simplemenus).menuhand, "DRVR");
  698.     #else
  699.       AddResMenu ((**simplemenus).menuhand, 'DRVR');
  700.     #endif
  701.     InsertMenu ((**simplemenus).menuhand, 0);
  702.     HUnlock (simplemenus);
  703.  
  704.     menu ("File", "New", (ProcPtr)ItemDisable);
  705.     menu ("Edit", "Undo", stnop);
  706.     menu ("Edit", "-", (ProcPtr)ItemDisable);
  707.     menu ("Edit", "Cut/X", stnop);
  708.     menu ("Edit", "Copy/C", stnop);
  709.     menu ("Edit", "Paste/V", stnop);
  710.     menu ("Edit", "Clear", stnop);
  711. }
  712.  
  713. /* Local procedure */
  714.  
  715. #ifndef LIGHTSPEED
  716. gottrans () 
  717. {
  718.   char prog[80];
  719.   char *argv[3];
  720.   if ( getfile("APPL", prog) ) {
  721.     argv[1] = NULL;
  722.     execv (prog, argv);
  723.   }
  724. }
  725. #endif
  726.  
  727. /* Local procedure */
  728.  
  729. gotquit ()
  730. {
  731.   exit(0);
  732. }
  733.  
  734. /* This routine is for the Windows menu Item.  The Windows menu is
  735.    set up when new windows are added.  It is used to bring forward and
  736.    bring into view windows that may be under other windows or have been
  737.    sent hiding by a click on their close box.
  738. */
  739.  
  740. /* Local procedure */
  741.  
  742. showawindow(name)            /* show the named window    */
  743. char *name;
  744. {
  745.     WindowPtr foo;
  746.     foo = windowpoint(name);    /* get its window pointer    */
  747.     if ( foo ) {
  748.         ShowWindow(foo);    /* show it on the screen    */
  749.         SetPort (foo);        /* set further output to it */
  750.         if ( foo != FrontWindow())    /* if it isn't active,    */
  751.             SelectWindow (foo);    /* activate it         */
  752.     }
  753. }
  754.  
  755. /* Local procedure */
  756.  
  757. winddatum **wdatum(windpt)        /* return Handle to window data */
  758. WindowPtr windpt;
  759. {
  760.     winddatum **wind, **temp;
  761.  
  762.     if (firstwind) return ((winddatum **) 0L);
  763.     wind = simplewinds;
  764.     HLock (wind);
  765.  
  766.     while ( ((**wind).wptr != windpt) && (**wind).next) {
  767.         temp = wind;
  768.         wind = (winddatum **) (**wind).next;
  769.         HUnlock (temp);
  770.         HLock (wind);
  771.     }
  772.  
  773.     if ( (**wind).wptr == windpt) {
  774.         HUnlock (wind);
  775.         return (wind);
  776.     } else {
  777.         HUnlock (wind);
  778.         return ((winddatum **) 0L);    /* zero if not found */
  779.     }
  780. }
  781.   
  782. /* Local procedure */
  783.  
  784. runruns(event)            /* run all the installed run procedures    */
  785. EventRecord *event;        /* returns number of routines run     */
  786. {
  787.     int i=0;
  788.     WindowPtr saveport;
  789.     GetPort (&saveport);
  790.     while ( simpleruns[i] )
  791.         (*(simpleruns[i++])) (event);
  792.     SetPort (saveport);
  793.     return(i);
  794. }
  795.  
  796. /* Local procedure */
  797.  
  798. stdialog( question, answer, type)  /* a general dialog displayer     */
  799. char *question;
  800. char *answer;
  801. int  type;            /* type:  1=prompt, 2=message         */
  802. {
  803.     DialogPtr dialog;    /* dialog reference             */
  804.     Handle Item, items;    /* handles for the dialog items     */
  805.     Rect screen, box;    /* rectangles for dialog/items         */
  806.     int dtype, hit, canc;    /* Item type and which was hit         */
  807.     char tempanswer[255];    /* address where answer is         */
  808.  
  809.     items = NewHandle (512L);/* get memory for items list         */
  810.     HLock (items);        /* lock it down             */
  811.     if (type == 1)
  812.         BlockMove (quesd, *items, (long) QUESN * 2L); 
  813.     else
  814.         BlockMove (messd, *items, (long) MESSN * 2L);
  815.     SetRect (&screen, 103, 50, 409, 137);        
  816.     
  817.     /* For LIGHTSPEED, use a lower case d and upper case B and P    */
  818.     /* for DBoxProc.  Megamax conversion utility does this wrong.    */
  819.     
  820.     dialog = NewDialog (0L, &screen, "", 0, dBoxProc, -1L, 0, 0L, items);
  821.     GetDItem (dialog, 2, &dtype, &Item, &box);
  822.     ctop (question);    
  823.     SetIText (Item, question);        /* set Item#2 text     */
  824.     ptoc (question);
  825.     if (type == 1) {            /* set default answer    */
  826.         GetDItem (dialog, 3, &dtype, &Item, &box);
  827.         ptoc (answer);
  828.         SetIText (Item, answer);
  829.         ctop (answer);
  830.         canc = 4;
  831.     } else
  832.         canc = 3;
  833.     ShowWindow (dialog);            /* display the dialog    */
  834.     do {
  835.         ModalDialog (0L, &hit);        /* process the dialog    */
  836.     } while ( (hit != 1) & (hit != canc) );
  837.     if (type == 1) {
  838.         GetDItem (dialog, 3, &dtype, &Item, &box);
  839.         HLock (Item);
  840.         GetIText (Item, tempanswer);    /* get Item#3 text     */
  841.         ptoc (tempanswer);
  842.         strcpy (answer, tempanswer);    /* make a copy of it     */
  843.         HUnlock (Item);
  844.     }
  845.     HUnlock(items);                /* unlock items memory    */
  846.     HPurge(items);                /* purge it         */
  847.     DisposDialog (dialog);            /* get rid of dialog    */
  848.     return ( hit==1 );            /* return true if ok    */
  849. }  
  850.   
  851. /* Local procedures */
  852.  
  853. docommand (which, thisevent)
  854. long which;
  855. EventRecord *thisevent;
  856. {
  857.     int themenu, theitem;
  858.     long size;
  859.     char *cpoint;
  860.     GrafPtr tempport;
  861.     menudatum **here, **temp;
  862.     itemdatum **items, **tempitems;
  863.     char **myreshandle;
  864.     Handle myhandle;
  865.   
  866.     themenu = HiWord (which);
  867.     theitem = LoWord (which);
  868.     if ((themenu == 1) && (theitem != 1)) {
  869.   
  870.         /* start up a desk accessory */
  871.         HLock (simplemenus);
  872.         GetItem ((**simplemenus).menuhand, theitem, accname);
  873.         SetResLoad (FALSE);
  874.         #ifdef MEGAMAX
  875.           myreshandle = GetNamedResource ("DRVR", accname);
  876.         #else
  877.           myreshandle = GetNamedResource ('DRVR', accname);
  878.         #endif
  879.         SetResLoad (TRUE);
  880.         size = SizeResource (myreshandle);
  881.         myhandle = NewHandle ( size + 3072L);
  882.         if (myhandle == 0L) 
  883.             message ("Not enough memory to do that.");
  884.         else {
  885.             DisposHandle (myhandle);
  886.             GetPort (&tempport);
  887.             OpenDeskAcc(accname);
  888.             SetPort (tempport);
  889.         }
  890.         HUnlock (simplemenus);
  891.         return;
  892.     }
  893.     if (themenu ==3) {
  894.         /* do any system edits */
  895.         if (SystemEdit(theitem -1))  return;
  896.     }
  897.   
  898.     /* now we run an installed menu procedure */
  899.     here = simplemenus;
  900.     HLock (here);
  901.   
  902.     /* find out menu structure given the menu id */
  903.     while ( ((**here).menuId != themenu) && (**here).next) {
  904.         temp = here;
  905.         here = (menudatum **)(**here).next;
  906.         HUnlock (temp);
  907.         HLock (here);
  908.     }
  909.   
  910.     if ((**here).menuId == themenu) {
  911.   
  912.         /* now find the Item structure */
  913.         items = (**here).itemlist;
  914.         HUnlock (here);
  915.         HLock (items);
  916.  
  917.         while ( ((**items).itemno != theitem) && (**items).next) {
  918.             tempitems = items;
  919.             items = (itemdatum **)(**items).next;
  920.             HUnlock (tempitems);
  921.             HLock (items);
  922.         }
  923.   
  924.         /* prepare to give the Item name to the procedure */
  925.         cpoint = (**items).itemname;
  926.         if ((**items).itemno == theitem) 
  927.         /* if we found the Item, call its procedure */
  928.             (*((**items).menurun))(cpoint,thisevent) ;
  929.         HUnlock (items);
  930.     }
  931. }
  932.  
  933. /* Local procedure */
  934.  
  935. domousedown(thisevent)        /* respond to mouse down events */
  936. EventRecord *thisevent;        /* passed the event record */
  937. {
  938.     WindowPtr whichwindow;
  939.     int code, x, y;
  940.     char *cpoint;
  941.     menudatum **omhand;
  942.     winddatum **thewdatum;
  943.     long newplace;
  944.     Point temp;
  945.     GrafPtr saveport;
  946.  
  947.     code = FindWindow(ZZ(thisevent->where), &whichwindow);
  948.     switch (code) {
  949.         case inMenuBar:
  950.         docommand(MenuSelect(ZZ(thisevent->where)),thisevent);
  951.         break;
  952.         case inSysWindow:
  953.         SystemClick(thisevent, whichwindow); break;
  954.         case inDrag:
  955.         DragWindow(whichwindow, ZZ(thisevent->where),
  956.             &dragrect); break;
  957.         case inGrow:
  958.         newplace= GrowWindow(whichwindow, ZZ(thisevent->where),
  959.             &sizerect);
  960.         SizeWindow(whichwindow, LoWord(newplace), 
  961.         HiWord(newplace), TRUE);
  962.         if (sizeredraw) {
  963.             GetPort (&saveport);
  964.             SetPort (whichwindow);
  965.             EraseRect (&swholescreen);
  966.             InvalRect (&swholescreen);
  967.             SetPort (saveport);
  968.         }
  969.         break;
  970.         case inGoAway:
  971.         if ( TrackGoAway(whichwindow, ZZ(thisevent->where))) {
  972.             HideWindow (whichwindow);
  973.         }
  974.         break;
  975.         case inzoomout:
  976.         case inzoomin:
  977.             #ifdef MEGAMAX
  978.           if ( trackbox(whichwindow, ZZ(thisevent->where), code)) {
  979.             zoomwindow (whichwindow, code, 0);
  980.         #else
  981.           if ( TrackBox(whichwindow, ZZ(thisevent->where), code)) {
  982.             ZoomWindow (whichwindow, code, 0);
  983.         #endif
  984.             GetPort (&saveport);
  985.             SetPort (whichwindow);
  986.             EraseRect (&swholescreen);
  987.             InvalRect (&swholescreen);
  988.             SetPort (saveport);
  989.         }
  990.         break;
  991.         case inContent:
  992.         
  993.         /* make the window active if it isn't yet */
  994.         if (whichwindow != FrontWindow()) {
  995.             SelectWindow(whichwindow);
  996.         }
  997.   
  998.         /* find our window data */
  999.         thewdatum = wdatum (whichwindow);
  1000.         if (thewdatum) {
  1001.           
  1002.             /* convert the Point of click to the window's
  1003.                own coordinates since this will be always
  1004.                more useful than the global coordintates */
  1005.             temp = thisevent->where;
  1006.             SetPort (whichwindow);
  1007.             GlobalToLocal (&temp);
  1008.             #ifdef MEGAMAX
  1009.               x = temp.a.h;
  1010.               y = temp.a.v;
  1011.             #else
  1012.               x = temp.h;
  1013.               y = temp.v;
  1014.             #endif
  1015.             
  1016.             /* call the window's in content routine */
  1017.             HLock (thewdatum);
  1018.             (*((**thewdatum).wcontent))(x, y, whichwindow,
  1019.                 thisevent);
  1020.             HUnlock (thewdatum);
  1021.         }
  1022.         break;
  1023.     }
  1024. }
  1025.             
  1026.  
  1027. /************************************************************************/
  1028. /*     GLOBAL ROUTINES INTENDED TO BE USER CALLABLE PROCEDURES        */
  1029. /* THE FOLLOWING PROCEDURES HAVE BEEN WRITTEN FOR THE USER'S         */
  1030. /* APPLICATION TO CALL.                            */
  1031. /*                                     */
  1032. /************************************************************************/
  1033.  
  1034. havenewrom ()            /* returns true if new roms installed    */
  1035. {
  1036.     return ((*((int *)ROM85)) == NEWROM);
  1037. }
  1038.  
  1039. /* Menu is usually called like:
  1040.  
  1041.         menu ("File", "Print...", got_print)
  1042.         
  1043.    where the first argument is the name appearing on the menubar.  The
  1044.    2nd argument is the name appearing when the menu is pulled down.  The
  1045.    3rd argument is USUALLY the routine to be called when the user
  1046.    selects this particular menu.  Non-existant menus are created following
  1047.    the last.  The menu ordering may never be changed once created.
  1048.    Existint menus have their "routine-to-be-executed" assignment changed
  1049.    to the new routine.  If the long values 0L, 1L, 2L, or 3L are passed
  1050.    instead of a procedure, the menu characteristic is set as specified
  1051.    by the constants ItemDisable, itemenable, itemcheck, itemuncheck.  For
  1052.    example:
  1053.            menu ("File", "Print...", ItemDisable)
  1054.         
  1055.    PROCEDURES ASSIGNED TO MENUS ARE CALLED WITH TWO ARGUMENTS.  YOU
  1056.    DO NOT NEED TO DECLARE THESE IN YOUR PROCEDURE IF YOU DO NOT USE
  1057.    THEM.  FOR EXAMPLE, GOT_PRINT MAY BE DECLARED AS:
  1058.    
  1059.            got_print()
  1060.         char *itemname;
  1061.         EventRecord *current_event;
  1062.         {
  1063.             ...
  1064.         }
  1065.         
  1066.    Itemname is a char* pointing to the Item name.  This allows the same
  1067.    menu procedure to be used for multiple menu/Item pairs.  Maybe your
  1068.    Size menu just as items 9 Point, 10 Point, 12 Point, etc.  This way
  1069.    you can specify the same procedure for each and determine what to do
  1070.    by looking at itemname.  
  1071.    
  1072.    Current_event is a pointer to the current EventRecord that detected
  1073.    the menu selection.  You may look at this as needed.
  1074. */
  1075.    
  1076. menu (name, Item, routine)        /* install or change a menu    */
  1077. char *name;                /* the menu name         */
  1078. char *Item;                /* the Item name         */
  1079. ProcPtr routine;            /* a procedure or modifier     */
  1080. {
  1081.     menudatum **here,**temp;    /* a roving Handle to our data     */
  1082.     menudatum **ourmhandle;        /* another Handle to our data     */
  1083.     itemdatum **items,**tempitems;    /* a Handle to the Item     */
  1084.     int lastid, lastitem;
  1085.     
  1086.     /* get the Handle to menu named 'name' */
  1087.     if ((ourmhandle = getourmenuhandle (name)) == 0L) {
  1088.     
  1089.         /* make a new menu entry by finding the end of the list */
  1090.         here = simplemenus;
  1091.         HLock (here);
  1092.         while ((**here).next) {
  1093.             temp = here;
  1094.             here = (menudatum **)(**here).next;
  1095.             HUnlock (temp);
  1096.             HLock (here);
  1097.         }
  1098.             
  1099.         /* make a structure for our new entry */
  1100.         lastid = (**here).menuId;
  1101.         (**here).next = (Ptr)NewHandle ( (long)sizeof(menudatum));
  1102.         temp = here;
  1103.         here = (menudatum **)(**here).next;
  1104.         HUnlock (temp);
  1105.         HLock (here);
  1106.  
  1107.         strcpy ( (**here).menuname, name);
  1108.         (**here).menuId = ++lastid;
  1109.         (**here).next = (Ptr) 0L;
  1110.         
  1111.         /* make a new Item structure */
  1112.         (**here).itemlist = (itemdatum **)NewHandle ( 
  1113.             (long)sizeof(itemdatum));
  1114.             
  1115.         /* make a new menu entry for the Macintosh */
  1116.         ctop (name);
  1117.         (**here).menuhand = NewMenu (lastid, name);
  1118.         ptoc (name);
  1119.         items = (**here).itemlist;
  1120.  
  1121.         HLock (items);
  1122.         strcpy ((**items).itemname, Item);
  1123.         (**items).itemno = 1;
  1124.         (**items).menuId = lastid;
  1125.         (**items).menuhand = (**here).menuhand;
  1126.         (**items).menurun = (ProcPtr) 0L;
  1127.         (**items).next = 0L;
  1128.         HUnlock (items);
  1129.         
  1130.         /* install and display the menu */
  1131.         ctop (Item);
  1132.         AppendMenu ((**here).menuhand, Item);
  1133.         ptoc (Item);
  1134.         InsertMenu ((**here).menuhand,0);
  1135.         HUnlock (here);
  1136.  
  1137.         setitems (items, routine);
  1138.         DrawMenuBar();
  1139.         return(TRUE);
  1140.     }
  1141.     else {
  1142.         HLock (ourmhandle);
  1143.  
  1144.         if (strlen(Item) == 0) {
  1145.           /* then adjust main menu */
  1146.           setitems( 0L - (long) ((**ourmhandle).menuhand), routine);
  1147.           return(FALSE);
  1148.         }
  1149.  
  1150.         /* see if Item is in list */
  1151.         items = (**ourmhandle).itemlist;
  1152.         HLock (items);
  1153.  
  1154.         while ( strcmp(Item,(**items).itemname) && (**items).next) {
  1155.             tempitems = items;
  1156.             items = (itemdatum **)(**items).next;
  1157.             HUnlock (tempitems);
  1158.             HLock (items);
  1159.         }
  1160.         if (strcmp(Item,(**items).itemname) ==0) {
  1161.             setitems( items, routine);
  1162.             return(FALSE);
  1163.         }
  1164.         else {
  1165.             /* make new Item entry */
  1166.             lastitem = (**items).itemno;
  1167.             (**items).next =(Ptr)NewHandle((long)sizeof(itemdatum));
  1168.             tempitems = items;
  1169.             items = (itemdatum **)(**items).next;
  1170.             HUnlock (tempitems);
  1171.             HLock (items);
  1172.  
  1173.             strcpy ((**items).itemname, Item);
  1174.             (**items).itemno = ++lastitem;
  1175.             (**items).menuId = (**ourmhandle).menuId;
  1176.             (**items).menuhand = (**ourmhandle).menuhand;
  1177.             (**items).menurun = (ProcPtr) 0L;
  1178.             (**items).next = 0L;
  1179.             HUnlock (items);
  1180.  
  1181.             /* and install the Item in the menu bar */
  1182.             ctop (Item);
  1183.             AppendMenu ((**ourmhandle).menuhand,Item);
  1184.             ptoc (Item);
  1185.             HUnlock (ourmhandle);
  1186.             setitems (items, routine);
  1187.             return(TRUE);
  1188.         }
  1189.     }
  1190. }
  1191.  
  1192. /* Given a menu name, return the real menu Handle as used by most
  1193.    of the Macintosh toolbox menu manager routines.
  1194. */
  1195.  
  1196. MenuHandle mhand (name)            /* find MenuHandle        */
  1197. char *name;                /* given name of menu         */
  1198. {
  1199.     menudatum    **menu;    
  1200.     MenuHandle    temp;        /* a Handle to our data     */
  1201.  
  1202.     menu = getourmenuhandle(name);
  1203.     if ( menu ) {
  1204.         HLock (menu);
  1205.         temp = (**menu).menuhand;
  1206.         HUnlock (menu);
  1207.         return ( temp );    /* return menu Handle         */
  1208.     } else
  1209.         return ( (MenuHandle) 0 );    
  1210. }
  1211.  
  1212.     
  1213. /*  Call this routine if you want these SimpleTools defined quiting    */
  1214. /*  procedures.  You may just install your own instead.     The time to    */
  1215. /*  call this is after you have installed all your other "File" items.    */
  1216. /*  By calling this last, you will place Transfer and Quit on the end    */
  1217. /*  of the menu list.                            */
  1218.  
  1219. simplequits ()
  1220. {
  1221.     menu ("File", "-", ItemDisable);
  1222.     
  1223.     #ifndef LIGHTSPEED
  1224.     menu ("File", "Transfer.../T", gottrans);
  1225.     #endif
  1226.     
  1227.     menu ("File", "Quit/Q", gotquit);
  1228. }
  1229.  
  1230. /* Given a window's name, return its window pointer so that other
  1231.    Macintosh Window Manager routines can be called for that window. */
  1232.  
  1233. WindowPtr windowpoint(name)        /* get window pointer         */
  1234. char *name;                /* given window's name         */
  1235. {
  1236.     winddatum **wind, **tempwind;    /* Handle to our window data     */
  1237.     WindowPtr    temp;
  1238.  
  1239.     if (firstwind) return ((WindowPtr)0); 
  1240.     wind = simplewinds;        /* look for the named window     */
  1241.     HLock (wind);
  1242.  
  1243.     while ( strcmp ((**wind).windname, name) && (**wind).next) {
  1244.         tempwind = wind;
  1245.         wind = (winddatum **) (**wind).next;
  1246.         HUnlock (tempwind);
  1247.         HLock (wind);
  1248.     }
  1249.     if ( strcmp ((**wind).windname, name) ==0) {
  1250.         temp = (**wind).wptr;
  1251.         HUnlock (wind);
  1252.         return ( temp );    /* return pointer        */
  1253.     } else {
  1254.         HUnlock (wind);
  1255.         return ( (WindowPtr) 0);/* or zero if it wasn't found    */
  1256.     }
  1257. }
  1258.  
  1259. /* This routine installs a new window onto the screen.  It also gives
  1260.    that window an Item in the Window menu.  This routine is also used
  1261.    to modify a window's associated routines.  The x,y positions are the
  1262.    top left and bottom right corners of where the window should originally
  1263.    be placed.  The coordinates are never used when this routine is called
  1264.    to update an already existing window.  But the spaces must be filled,
  1265.    so you can use zeros if you want.  Once the window has been displayed in
  1266.    its original position, the user has complete control of its size and
  1267.    placement with the mouse.
  1268.    
  1269.    YOU MUST ASSIGN PROCEDURES TO BE CALLED WHEN SIMPLETOOLS DETECTS THAT
  1270.    THIS WINDOW IS BECOMMING ACTIVE, DEACTIVATING, NEEDS UPDATING, OR
  1271.    THE MOUSE HAS BEEN PRESSED IN ITS CONTENT.  JUST LIKE THE MENU PROCEDURE,
  1272.    THESE PROCEDURES ARE PASSED SOME ARGUMENTS.  YOU DO NOT HAVE TO 
  1273.    DECLARE THESE IF YOU DON'T WHAT TO USE THEM.  IF YOU USE THE ARGUMENTS,
  1274.    YOU WOULD DECLAR THESE PROCEDURES AS FOLLOWS:
  1275.    
  1276.        my_activate (windp, event)    same as my_update
  1277.     my_deactivate (windp, event)    same as my_update
  1278.     
  1279.     my_update (windp, event)
  1280.     WindowPtr     windp;        the window being acted upon
  1281.     EventRecord     *event;        the current event record
  1282.     {
  1283.         ...
  1284.     }
  1285.     
  1286.     my_inContent (x, y, windp, event)
  1287.     int         x, y;        mouse position in local coords
  1288.     WindowPtr     windp;        like above
  1289.     EventRecord     *event;        like above
  1290.     {
  1291.         ...
  1292.     }
  1293. */
  1294.  
  1295. window(name, xtop, ytop, xbot, ybot, a, d, u, c)
  1296. char *name;            /* window's name             */
  1297. int xtop, ytop, xbot, ybot;    /* position if this is a new window     */
  1298. ProcPtr a, d, u, c;        /* activate, deactivate, update, and     */
  1299. {                /*  content procedures          */
  1300.     winddatum **wind, **temp;/* Handle to our window data         */
  1301.     winddatum **newentry;    /* another Handle             */
  1302.     Rect newplace;        /* rectable for the window's placement    */
  1303.  
  1304.     if (a == (ProcPtr) 0)
  1305.         a = stnop;
  1306.     if (d == (ProcPtr) 0)
  1307.         d = stnop;
  1308.     if (u == (ProcPtr) 0)
  1309.         u = stnop;
  1310.     if (c == (ProcPtr) 0)
  1311.         c = stnop;
  1312.     if ( !firstwind ) {
  1313.  
  1314.         /* see if window is in the list */
  1315.         wind = simplewinds;
  1316.         HLock (wind);
  1317.  
  1318.         while ( strcmp ((**wind).windname, name) && (**wind).next) {
  1319.             temp = wind;
  1320.             wind = (winddatum **) (**wind).next;
  1321.             HUnlock (temp);
  1322.             HLock (wind);
  1323.         }
  1324.         if ( strcmp ((**wind).windname, name) ==0) {
  1325.  
  1326.             /* reset the found window's parameters */
  1327.             (**wind).wact = (ProcPtr) a;
  1328.             (**wind).wdeact = (ProcPtr) d;
  1329.             (**wind).wupdate = (ProcPtr) u;
  1330.             (**wind).wcontent = (ProcPtr) c;
  1331.             SetPort ( (**wind).wptr);        
  1332.             HUnlock (wind);
  1333.  
  1334.             return(FALSE);
  1335.         }
  1336.     }
  1337.  
  1338.     /* make a new window entry */
  1339.     newentry = (winddatum **)NewHandle ( (long) sizeof (winddatum));
  1340.     if (firstwind)
  1341.         simplewinds = newentry;
  1342.     else
  1343.         (**wind).next = (Ptr) newentry;
  1344.     firstwind = 0;
  1345.     HUnlock (wind);
  1346.     HLock (newentry);
  1347.  
  1348.     strcpy ((**newentry).windname, name);
  1349.     SetRect (&newplace, xtop, ytop, xbot, ybot);
  1350.     if (EmptyRect (&newplace)) 
  1351.         SetRect (&newplace, 10, 42, 500, 330);
  1352.     ctop (name);
  1353.     (**newentry).wptr = NewWindow (0L, &newplace, name, -1, 
  1354.         wprocid, -1L, dogoaway, newentry);
  1355.     ptoc (name);
  1356.     (**newentry).wact = (ProcPtr) a;
  1357.     (**newentry).wdeact = (ProcPtr) d;
  1358.     (**newentry).wupdate = (ProcPtr) u;
  1359.     (**newentry).wcontent = (ProcPtr) c;
  1360.     (**newentry).next = (Ptr) 0;
  1361.     if (windmenu)
  1362.         menu ("Windows", name, showawindow); 
  1363.     SetPort ( (**newentry).wptr);        
  1364.     HUnlock (newentry);
  1365.  
  1366.     return(TRUE);
  1367. }
  1368.  
  1369. withwindow(name)            /* set output to window by name    */
  1370. char *name;                /* give it the window's name     */
  1371. {                    /* returns if window exists    */
  1372.     winddatum **wind, **temp;
  1373.     wind = simplewinds;
  1374.     if (firstwind) return(FALSE);    /* search for the window's name */
  1375.  
  1376.     HLock (wind);
  1377.     while ( strcmp ((**wind).windname, name) && (**wind).next) {
  1378.         temp = wind;
  1379.         wind = (winddatum **) (**wind).next;
  1380.         HUnlock (temp);
  1381.         HLock (wind);
  1382.     }
  1383.     if ( strcmp ((**wind).windname, name) ==0) {
  1384.         SetPort ( (**wind).wptr);    /* set output to it     */
  1385.         HUnlock (wind);
  1386.         return(TRUE);
  1387.     } else {
  1388.         HUnlock (wind);
  1389.         return(FALSE);
  1390.     }
  1391. }
  1392.   
  1393. /* This run procedure is used to install routines to be occasionally
  1394.    run.  The routine will be run once for each call to simpleevents()
  1395.    which is done repeatedly by runsimpletools().
  1396.    
  1397.    EACH ROUTINE INSERTED INTO THE RUN LIST IS RUN MULTIPLE TIMES UNTIL
  1398.    IT IS REMOVED BY CALLING STOP.  THE ROUTINE IS CALLED WITH A SINGLE
  1399.    ARGUMENT, A POINTER TO THE EVENT JUST RETURNED BY GETNEXTEVENT() AND
  1400.    BEFORE SIMPLETOOLS PROCESSES IT.
  1401. */
  1402.  
  1403. run(routine)            /* install a run procedure     */
  1404. ProcPtr routine;        /* give it the procedure     */
  1405. {                /* return TRUE if successful     */
  1406.     int i;
  1407.     i = 0;            /* add it to the end of the list */
  1408.     while ( simpleruns[i] != (ProcPtr) 0L) i++;
  1409.     if (i < maxsruns) {
  1410.         simpleruns[i] = routine;
  1411.         simpleruns[i+1] = (ProcPtr) 0L;
  1412.         return(TRUE);
  1413.     } else
  1414.         return(FALSE);
  1415. }
  1416.  
  1417. /* This routine removes a procedure from the list of run procedures */
  1418.  
  1419. stop(routine)            /* stop a procedure from running*/
  1420. ProcPtr routine;        /* give the procedure         */
  1421. {                /* return TRUE if successful     */
  1422.     int i = 0;
  1423.     while ( (simpleruns[i] != routine) && simpleruns[i])  i++;
  1424.     if (simpleruns[i]) {
  1425.         while ( simpleruns[i] != (ProcPtr)0 ) {
  1426.             simpleruns[i] = simpleruns[i+1];
  1427.             i++;
  1428.         }
  1429.         return(TRUE);
  1430.     } else {
  1431.         return(FALSE);
  1432.     }
  1433. }
  1434.  
  1435. home ()                /* text-based home of the pen with
  1436.                    the window being erased.        */
  1437. {
  1438.     GrafPtr    port;
  1439.     GetPort (&port);
  1440.     EraseRect (&(port->portRect));
  1441.     stgotoxy (1, 1);
  1442. }
  1443.  
  1444. stgotoxy (x, y)                /* goto text position x, y    */
  1445. int x, y;    
  1446. {
  1447.     Point        pt;
  1448.     int        newx, newy;
  1449.     FontInfo    font;
  1450.   
  1451.     GetFontInfo (&font);
  1452.     GetPen (&pt);
  1453.     #ifdef MEGAMAX
  1454.     if (x < 0) 
  1455.         newx = pt.a.h;
  1456.     else
  1457.         newx = font.widMax * (x);
  1458.     if (y < 0)
  1459.         newy = pt.a.v;
  1460.     #else
  1461.     if (x < 0) 
  1462.         newx = pt.h;
  1463.     else
  1464.         newx = font.widMax * (x);
  1465.     if (y < 0)
  1466.         newy = pt.v;
  1467.     #endif
  1468.     else
  1469.         newy = (font.ascent + font.descent + font.leading) * (y+1);
  1470.     MoveTo (newx, newy);
  1471. }
  1472.  
  1473. /* The getline procedure is to be called when you want to simply get a Line
  1474.    of text from the user at the current pen position on the screen.  You
  1475.    will probably preceed this with a call to stgotoxy(x,y).  You would call
  1476.    it like:    
  1477.            getline ("Erik", name);
  1478.         
  1479.    where name is a character array.  This works MUCH better than scanf()
  1480.    or gets() since it uses the Macintosh TextEdit routines to allow the
  1481.    user to edit the Line being input.
  1482.    
  1483.    Getline is very "modal" and no other events are handled while the
  1484.    user is expected to enter the Line.  Getline returns ONLY when the
  1485.    user presses <RETURN>.  
  1486.    
  1487.    Routines scheduled to run by the run() routine are called.  Make sure
  1488.    your run routines don't strip all <RETURNS> from the event record
  1489.    they get or getline will never stop.
  1490. */
  1491.    
  1492. getline (dfault, destination)        /* using TE, get a Line        */
  1493. char *dfault, *destination;        /* default string, dest     */
  1494. {
  1495.     TEHandle         hte;
  1496.     Rect            destRect;
  1497.     Point            pen,pt;
  1498.     FontInfo        FInfo;
  1499.     int            done, mask, code, in_already, nextcap;
  1500.     GrafPtr            port, window;
  1501.     EventRecord        event;
  1502.     char            key;
  1503.     CursHandle        c;
  1504.     
  1505.     GetPort (&port);        /* Calculate Rect for TE    */
  1506.     if (port != FrontWindow())  SelectWindow (port);
  1507.     GetPen (&pen);
  1508.     GetFontInfo (&FInfo);
  1509.     #ifdef MEGAMAX
  1510.         SetRect (&destRect, pen.a.h, pen.a.v - FInfo.ascent,
  1511.             1000, pen.a.v + FInfo.descent);
  1512.     #else
  1513.         SetRect (&destRect, pen.h, pen.v - FInfo.ascent,
  1514.             1000, pen.v + FInfo.descent);
  1515.     #endif
  1516.     EraseRect (&destRect);
  1517.     hte = TENew (&destRect, &destRect);    
  1518.     TESetText (dfault, (long)strlen(dfault), hte);
  1519.     TEActivate (hte);
  1520.     TEUpdate (&destRect, hte);
  1521.     mask = mDownMask + keyDownMask + autoKeyMask + mUpMask;
  1522.     done = FALSE;
  1523.     #ifdef MEGAMAX
  1524.       c = GetCursor (ibeamcursor);
  1525.     #else
  1526.       c = GetCursor (iBeamCursor);
  1527.     #endif
  1528.     in_already = FALSE;
  1529.     nextcap = getlinecaps;
  1530.     do {                /* "modal" loop until <cr>    */
  1531.         SystemTask ();
  1532.         TEIdle (hte);
  1533.         
  1534.         GetNextEvent (mask, &event);
  1535.         runruns (&event);
  1536.         GetMouse (&pt);        /* use I beam in TE        */
  1537.         if (PtInRect (ZZ(pt), &destRect)) {
  1538.           if ( ! in_already )  {
  1539.              SetCursor (*c);
  1540.              in_already = TRUE;
  1541.           }
  1542.         } else {
  1543.           if ( in_already ) {
  1544.               InitCursor ();
  1545.               in_already = FALSE;
  1546.           }
  1547.         }
  1548.         switch (event.what) {
  1549.             case mouseDown:
  1550.             code = FindWindow (ZZ(event.where),&window);
  1551.             if ((code == inContent) && (window == port)) {
  1552.                GlobalToLocal (&event.where);
  1553.                 if (PtInRect(ZZ(event.where),&destRect))
  1554.                     TEClick (ZZ(event.where), 0, hte);
  1555.                 else SysBeep (1);
  1556.             } else SysBeep (20);
  1557.             break;
  1558.             case keyDown:
  1559.             case autoKey:
  1560.                 key = (char) (event.message & 0xFFL);
  1561.             if (nextcap && (key >= 'a') && (key <= 'z')) 
  1562.                 key -= ' ';
  1563.             nextcap = FALSE;
  1564.             if (key == ' ') nextcap = getlinecaps;
  1565.             if (key != '\r')  TEKey (key, hte);
  1566.             else  done = TRUE;
  1567.             break;
  1568.         }
  1569.     } while (!done);
  1570.     TEDeactivate (hte);
  1571.     
  1572.     /* For LIGHTSPEED, use a lowercase te and upper case L in    */
  1573.     /* TElength.  Megamax conversion utility does this wrong too.    */
  1574.     
  1575.     strncpy (destination, *TEGetText(hte), (*hte)->teLength);
  1576.     destination[(*hte)->teLength] = 0;
  1577.  
  1578.     TEDispose (hte);
  1579.         InitCursor ();
  1580. }
  1581.  
  1582. /*  Use prompt when you want a tiny window to pop up to ask the user
  1583.     a question.  The question is drawn and a TextEdit box is provided
  1584.     to get the answer.  Whatever the user leaves in the answer box
  1585.     is returned in answer.  Two buttons are also displayed:  OK and
  1586.     CANCEL.  Prompt returns TRUE or FALSE depending on which Button was
  1587.     pressed.
  1588. */
  1589.  
  1590. prompt ( question, answer)        /* dialog box question/answer */
  1591. char *question;
  1592. char *answer;
  1593. {
  1594.     return (stdialog (question, answer, 1));
  1595. }
  1596.  
  1597. /* Message is just like prompt except no answer box is displayed.  An
  1598.    OK and CANCEL Button works just like prompt.
  1599. */
  1600.  
  1601. message ( message )            /* dialog box message         */
  1602. char *message;
  1603. {
  1604.     return (stdialog (message, message, 2));
  1605. }
  1606.   
  1607. /*  This routine is a simpler whay to call the toolbox SFGetFile()
  1608.     routine.  Simple call this like:
  1609.     
  1610.             getfile ("TEXT", filename)
  1611.         
  1612.     where filename is a character array.  Replace TEXT with whatever
  1613.     file type you desire.  The file manager's working directory is set
  1614.     correctly so that a subsequent open() call with filename will work.
  1615. */
  1616.  
  1617. getfile (ftype, reply)
  1618. char ftype[];
  1619. char reply[];
  1620. {
  1621.     Point where;
  1622.     SFReply frommac;
  1623.     
  1624.     #ifdef MEGAMAX
  1625.       where.a.h = 75; where.a.v = 50;
  1626.     #else
  1627.       where.h = 75; where.v = 50;
  1628.     #endif
  1629.     if (strlen(ftype) != 4)
  1630.       SFGetFile (ZZ(where), NULL, NULL, -1, NULL, NULL, &frommac);
  1631.     else
  1632.       SFGetFile (ZZ(where), NULL, NULL, 1, ftype, 0L, &frommac);
  1633.     if (frommac.good) {
  1634.       SetVol ("", frommac.vRefNum);
  1635.       strcpy (reply, frommac.fName);
  1636.       return (TRUE);
  1637.     }
  1638.     else return (FALSE);
  1639. }
  1640.  
  1641. /* This is like getfile, but may get a new file name from the user.
  1642.    Origname is the default you want to present to the user.
  1643. */
  1644.  
  1645. putfile (origname,reply)
  1646. char *origname;
  1647. SFReply *reply;
  1648. {
  1649.     Point where;
  1650.     SFReply frommac;
  1651.     
  1652.     #ifdef MEGAMAX
  1653.       where.a.h = 75; where.a.v = 50;
  1654.     #else
  1655.       where.h = 75; where.v = 50;
  1656.     #endif
  1657.     SFPutFile (ZZ(where), "", origname, 0L, &frommac);
  1658.     if (frommac.good) {
  1659.       SetVol ("", frommac.vRefNum);
  1660.       strcpy (reply, frommac.fName);
  1661.       return (TRUE);
  1662.     }
  1663.     return (FALSE);
  1664. }
  1665.  
  1666. /* This routine initializes SimpleTools and MUST be called before    */
  1667. /* most of the other SimpleTools routines are called.            */
  1668. /* The passed about string is the menu Item name to appear just under    */
  1669. /* the Apple menu.  This will be disabled and can be enabled using    */
  1670. /* a menu() call.  This routine also initializes the Macintosh         */
  1671. /* for application execution and desk accessory processing.        */
  1672.  
  1673. simpletools(about)    /* to be called at the beginning of program     */
  1674. char *about;
  1675. {
  1676.     #ifdef MEGAMAX
  1677.       maxapplzone();    /* allow maximum heap expansion     */
  1678.     #else
  1679.       MaxApplZone();
  1680.     #endif
  1681.     FlushEvents (everyEvent,0);  /* ignore left over events     */
  1682.     InitGraf (&thePort);    /* initialize the screen         */
  1683.     InitFonts();        
  1684.     InitWindows();
  1685.     InitMenus();
  1686.     InitCursor();        /* make the arrow Cursor         */
  1687.     TEInit();
  1688.     InitDialogs(0L);
  1689.     snewrom = havenewrom();
  1690.     
  1691.     /* Ugh.  For LightSpeed use a lower case d in DocumentProc.    */
  1692.     /* Megamax conversion utility is at fault here.            */
  1693.     
  1694.     wprocid = documentProc;
  1695.     if (snewrom) wprocid = zoomproc;
  1696.     SetRect ( &sizerect, 20, 50, 250, 330);
  1697.     simpleruns[0] = (ProcPtr) 0;  /* empty the run list         */
  1698.  
  1699.     /* These are the bounds we are allowed to size a window or
  1700.        Move a window to.  
  1701.     */
  1702.  
  1703.     swholescreen = dragrect = thePort -> portRect;
  1704.     InsetRect (&dragrect, 4, 4);
  1705.     SetRect ( &sizerect, 20, 20, 2048, 700);
  1706.     firstwind = 1;            /* empty window table        */
  1707.     keydownproc = stnop;        /* default key hit procedures     */
  1708.     autokeyproc = stnop;
  1709.     initsmenus(about);        /* install the menus         */
  1710. }
  1711.  
  1712. simpleevents()                /* to be called in the main loop */
  1713. {
  1714.     EventRecord newevent;
  1715.     winddatum **thewdatum;
  1716.     SystemTask();            /* Do the system D.A. etc. stuff */
  1717.     HiliteMenu(0);
  1718.     GetNextEvent(everyEvent, &newevent);
  1719.     runruns(&newevent);        /* Do our run procedures     */
  1720.     switch (newevent.what) {
  1721.         case mouseDown:
  1722.         domousedown(&newevent); break;
  1723.         case keyDown: 
  1724.         if (newevent.modifiers & cmdKey)
  1725.             docommand(MenuKey((char)(newevent.message & 0xffL)),
  1726.                 &newevent);
  1727.         (*(keydownproc))(&newevent);
  1728.          break;
  1729.         case autoKey: 
  1730.         if (newevent.modifiers & cmdKey)
  1731.             docommand(MenuKey((char)(newevent.message & 0xffL)),
  1732.                 &newevent);
  1733.         (*(autokeyproc))(&newevent);
  1734.         break;
  1735.         case activateEvt: 
  1736.         thewdatum = wdatum(newevent.message);
  1737.         if (thewdatum) {
  1738.             SetPort(newevent.message);
  1739.             HLock (thewdatum);
  1740.             if (newevent.modifiers & 1) {
  1741.  
  1742.                 (*((**thewdatum).wact))(newevent.message, 
  1743.                     &newevent);
  1744.             } else {
  1745.                 (*((**thewdatum).wdeact))(newevent.message,
  1746.                     &newevent);
  1747.             }
  1748.             HUnlock (thewdatum);
  1749.         }
  1750.         break;
  1751.         case updateEvt:
  1752.         thewdatum = wdatum(newevent.message);
  1753.         if (thewdatum) {
  1754.             SetPort (newevent.message);
  1755.             BeginUpdate (newevent.message);
  1756.             HLock (thewdatum);
  1757.             (*((**thewdatum).wupdate))(newevent.message,
  1758.                 &newevent);
  1759.             HUnlock (thewdatum);
  1760.             EndUpdate (newevent.message);
  1761.         }
  1762.         break;
  1763.     }
  1764. }
  1765.  
  1766. runsimpletools ()
  1767. {
  1768.     for (;;) simpleevents();
  1769. }
  1770. /* End of text from uiucdcsb:comp.sys.mac */
  1771.